home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1992 June: ROMin Holiday / ADC Developer CD (1992-06) (''ROMin Holiday'')_iso / Developer Connection - 06-1992.iso / Development Platforms / LISP Related / U. Mass AI & LISP Tools / MODULES / RULES / RULE-Demo.lisp < prev    next >
Encoding:
Text File  |  1990-06-25  |  15.8 KB  |  377 lines  |  [TEXT/CCL ]
  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ; File:         Rule-Demo.lisp
  3. ; Author:       Dan Suthers
  4. ; Created:      21-Mar-89 13:21:00
  5. ; Modified:     24-Jun-90 23:14:36 (Dan Suthers)
  6. ; Language:     Common Lisp
  7. ; Package:      USER
  8. ;
  9. ; Description:  Some examples to run rules on.  I've thrown together two
  10. ;               examples which I used for testing: reasoning about values 
  11. ;               in an electric circuit, and reasoning about relationships.
  12. ;               This demos mainly the backchainer.
  13. ;
  14. ;               Note that some of these examples show problems with the 
  15. ;               backchainer, in particular redundant reasoning.  I included
  16. ;               these to help you evaluate the limitations of this package.
  17. ; 
  18. ;               You should evalute the database and rule defining sections
  19. ;               as a group, but evaluate the individual rule invocations 
  20. ;               and graphing expressions one at a time to see what 
  21. ;               happens.  Use the graphical interface (clicking on nodes)
  22. ;               to examine the support tree, and the SM Browser to look 
  23. ;               at the rules.
  24. ;               
  25. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  26.  
  27. (in-package "USER")
  28.  
  29. (defun DEMO-GRAPH-SUPPORT-TREE (root-node)
  30.   (ccl:oneof grapher:*graph-window*
  31.              :window-title    (rule::label-string (rule::trj-node-claim root-node) 10 40)
  32.              :window-size     (ccl:make-point (- *screen-width* 4) 280)
  33.              :window-position (ccl:make-point 2 ccl:*menubar-bottom*)
  34.              :graph-view
  35.              (rule::trj-node->graph-view root-node
  36.                                          :vertical-tree
  37.                                          :as-found
  38.                                          6
  39.                                          nil)))
  40.  
  41. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  42. ;;;                 CIRCUITS: Forward and Back Chaining
  43. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  44. ;;; Representation of a circuit in a DNET database.  Evaluate all of this
  45. ;;; section as a group. Note here I use lower level DNET building functions 
  46. ;;; instead of MAKE-DATA-BASE and ADD-DATUM.
  47.  
  48. ;;; dnet:make-dnet is what rule:make-data-base calls (virtually identical).
  49.  
  50. (dnet:make-dnet ':CIRCUIT-1 
  51.   :indexpr-hook 'NIL
  52.   :delexpr-hook 'NIL
  53.   :info 'NIL)
  54.  
  55. (dnet:indexpr '(PORTS (BATTERY B1) (PORT PB1-1) (PORT PB1-2)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  56. (dnet:indexpr '(PORTS (RESISTOR R1) (PORT PR1-1) (PORT PR1-2)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  57. (dnet:indexpr '(PORTS (LIGHT L1) (PORT PL1-1) (PORT PL1-2)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  58. (dnet:indexpr '(PORTS (LIGHT L2) (PORT PL2-1) (PORT PL2-2)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  59. (dnet:indexpr '(VOLTAGE (BATTERY B1) (VOLTS 6)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  60. (dnet:indexpr '(RESISTANCE (RESISTOR R1) (OHMS 10)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  61. (dnet:indexpr '(RESISTANCE (LIGHT L1) (OHMS 2)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  62. (dnet:indexpr '(RESISTANCE (LIGHT L2) (OHMS 2)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  63. (dnet:indexpr '(WIRE (PORT PB1-1) (PORT PL1-1)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  64. (dnet:indexpr '(WIRE (PORT PB1-2) (PORT PL1-2)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  65. (dnet:indexpr '(WIRE (PORT PL1-1) (PORT PR1-1)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  66. (dnet:indexpr '(WIRE (PORT PL1-2) (PORT PL2-2)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  67. (dnet:indexpr '(WIRE (PORT PR1-2) (PORT PL2-1)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807247882)))
  68. (dnet:indexpr '(EFFICIENCY (LIGHT L2) (RATIO 2/3)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807249648)))
  69. (dnet:indexpr '(EFFICIENCY (LIGHT L1) (RATIO 2/3)) ':CIRCUIT-1 '(#S(RULE:JUSTIFICATION RULE::WARRANT :DATUM RULE::GROUNDS NIL TIME 2807249626)))
  70.  
  71. ;;; Get a bunch of variables out of the way ...
  72. (rule:DEFVARIABLES "A" "ATTRIBUTE" "C1" "C2" "CTYPE1" "CTYPE2" 
  73.                    "D" "DEV" "E" "INSTANCE1" "INSTANCE2" "L" 
  74.                    "LUM" "NEG-V" "OBJECT-TYPE" "P1" "P2" "P3" 
  75.                    "P4" "R" "R1" "R2" "SCALE" "V" "V1" "V2" "VALUE-TYPE")
  76.  
  77. (rule:rule BRIGHTNESS
  78.  :ANTECEDENT        
  79.  (:seq (ports (light ?:l) (port ?:p1) (port ?:p2))
  80.       (efficiency (light ?:l) (ratio ?:e))
  81.       (current (port ?:p1) (port ?:p2) (amps ?:a))
  82.       (:bind ?:lum (* ?:e ?:a)))
  83.  :CONSEQUENT        (brightness (light ?:l) (lumens ?:lum))
  84.  :DIRECTIONS        :backward
  85.  :INTERNED-IN       (:network-rules)
  86.  :INFO              ((:domain . :networks))
  87.  :COMMENTS          "Says how to find the brightness of a light as a function of current.")
  88.  
  89. (rule:rule OHMS-LAW-FOR-CURRENT
  90.  :ANTECEDENT        
  91.  (:seq (resistance (port ?:p1) (port ?:p2) (ohms ?:r))
  92.       (voltage (port ?:p1) (port ?:p2) (volts ?:v))
  93.       (:bind ?:a (/ ?:v ?:r)))
  94.  :CONSEQUENT        (current (port ?:p1) (port ?:p2) (amps ?:a))
  95.  :DIRECTIONS        :backward
  96.  :INTERNED-IN       (:network-rules)
  97.  :INFO              ((:domain . :networks))
  98.  :COMMENTS          "Given resistance and voltage across ports, provides current flow.")
  99.  
  100. (rule:rule PROPORTION
  101.  :ANTECEDENT        
  102.  (:seq (?:attribute (?:object-type ?:instance1) (?:value-type ?:v1))
  103.       (?:attribute (?:object-type ?:instance2) (?:value-type ?:v2))
  104.       (:bind ?:r (/ ?:v1 ?:v2)))
  105.  :CONSEQUENT        
  106.  (proportion (?:attribute (?:object-type ?:instance1))
  107.                   (?:attribute (?:object-type ?:instance2))
  108.                   (ratio ?:r))
  109.  :DIRECTIONS        :backward
  110.  :INTERNED-IN       (:network-rules)
  111.  :INFO              ((:domain . :networks))
  112.  :COMMENTS          "Says how to find the proportion between two attributes.")
  113.  
  114. (rule:rule RESISTANCE-ACROSS-DEVICE-PORTS
  115.  :ANTECEDENT        
  116.  (:and (ports (?:dev ?:d) (port ?:p1) (port ?:p2))
  117.       (resistance (?:dev ?:d) (?:scale ?:r)))
  118.  :CONSEQUENT        
  119.  (:and (resistance (port ?:p1) (port ?:p2) (?:scale ?:r))
  120.       (resistance (port ?:p2) (port ?:p1) (?:scale ?:r)))
  121.  :DIRECTIONS        :forward
  122.  :INTERNED-IN       (:network-rules)
  123.  :INFO              ((:domain . :networks))
  124.  :COMMENTS          "Assigns the resistance of a device to its ports.")
  125.  
  126. (rule:rule SERIES-CURRENT
  127.  :ANTECEDENT        
  128.  (:and
  129.  (series-network (port ?:p1)
  130.                        (port ?:p2)
  131.                        (port ?:p3)
  132.                        (port ?:p4))
  133.  (current (port ?:p1) (port ?:p4) (?:scale ?:a)))
  134.  :CONSEQUENT        (current (port ?:p3) (port ?:p4) (?:scale ?:a))
  135.  :DIRECTIONS        :backward
  136.  :INTERNED-IN       (:network-rules)
  137.  :INFO              nil
  138.  :COMMENTS          
  139.  "Says that the current across an entire series network is 
  140. also the current across subcomponents.")
  141.  
  142. (rule:rule SERIES-NETWORK
  143.  :ANTECEDENT        
  144.  (:and (ports (?:ctype1 ?:c1) (port ?:p1) (port ?:p2))
  145.       (ports (?:ctype2 ?:c2) (port ?:p3) (port ?:p4))
  146.       (wire (port ?:p2) (port ?:p3)))
  147.  :CONSEQUENT        
  148.  (:and
  149.  (series-network (port ?:p1)
  150.                        (port ?:p2)
  151.                        (port ?:p3)
  152.                        (port ?:p4))
  153.  (series-network (port ?:p4)
  154.                        (port ?:p3)
  155.                        (port ?:p2)
  156.                        (port ?:p1)))
  157.  :DIRECTIONS        :backward
  158.  :INTERNED-IN       (:network-rules)
  159.  :INFO              nil
  160.  :COMMENTS          "Defines simple series networks.")
  161.  
  162. (rule:rule SERIES-RESISTANCE
  163.  :ANTECEDENT        
  164.  (:seq
  165.  (series-network (port ?:p1)
  166.                        (port ?:p2)
  167.                        (port ?:p3)
  168.                        (port ?:p4))
  169.  (resistance (port ?:p1) (port ?:p2) (?:scale ?:r1))
  170.  (resistance (port ?:p3) (port ?:p4) (?:scale ?:r2))
  171.  (:bind ?:r (+ ?:r1 ?:r2)))
  172.  :CONSEQUENT        (resistance (port ?:p1) (port ?:p4) (?:scale ?:r))
  173.  :DIRECTIONS        :backward
  174.  :INTERNED-IN       (:network-rules)
  175.  :INFO              nil
  176.  :COMMENTS          "Finds the resistance of a series network by adding the resistance of the componenets.")
  177.  
  178. (rule:rule VOLTAGE-ACROSS-DEVICE-PORTS
  179.  :ANTECEDENT        
  180.  (:and (ports (?:dev ?:d) (port ?:p1) (port ?:p2))
  181.       (voltage (?:dev ?:d) (?:scale ?:v)))
  182.  :CONSEQUENT        
  183.  (:and (voltage (port ?:p1) (port ?:p2) (?:scale ?:v))
  184.       (voltage (port ?:p2) (port ?:p1) (?:scale (:lisp (- ?:v)))))
  185.  :DIRECTIONS        :forward
  186.  :INTERNED-IN       (:network-rules)
  187.  :INFO              ((:domain . :networks))
  188.  :COMMENTS          "Assigns the electromotive voltage to the ports of a device.")
  189.  
  190. (rule:rule VOLTAGE-PROPAGATION
  191.  :ANTECEDENT        
  192.  (:and (wire (port ?:p1) (port ?:p3))
  193.       (wire (port ?:p2) (port ?:p4))
  194.       (voltage (port ?:p1) (port ?:p2) (?:scale ?:v)))
  195.  :CONSEQUENT        (voltage (port ?:p3) (port ?:p4) (?:scale ?:v))
  196.  :DIRECTIONS        :backward
  197.  :INTERNED-IN       (:network-rules)
  198.  :INFO              ((:domain . :networks))
  199.  :COMMENTS          
  200.  "Propagate voltage to directly connected terminals. Voltage conjunct
  201. of antecedent must be last to prevent circularity.")
  202.  
  203. (rule:rule VOLTAGE-PROPAGATION-FLIP-SIGN
  204.  :ANTECEDENT        
  205.  (:seq (voltage-across (port ?:p1) (port ?:p2) (volts ?:v))
  206.       (connected (port ?:p1) (port ?:p3))
  207.       (connected (port ?:p2) (port ?:p4))
  208.       (:bind ?:neg-v (- ?:v)))
  209.  :CONSEQUENT        (voltage-across (port ?:p4) (port ?:p3) (volts ?:neg-v))
  210.  :DIRECTIONS        :backward
  211.  :INTERNED-IN       (:network-rules)
  212.  :INFO              ((:domain . :networks))
  213.  :COMMENTS          "Propagate voltage to directly connected terminals, where voltage must be negated.")
  214.  
  215. (dnet:make-dnet :network-rules)
  216. (rule:add-all-rules)
  217.  
  218. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  219. ;;; CIRCUIT REASONING - evaluate each form one at a time.
  220. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  221.  
  222. ;;; Turn rule trace on if you wish. Then evaluate these ...
  223.  
  224. ;;; Do forward chaining to get some simple facts.
  225.  
  226. (rule:forward-chain :circuit-1 :network-rules)
  227.  
  228. ;;; Simple retrieval of something got by forward chaining -- compare datum just.
  229.  
  230. (rule:support '(voltage (port pb1-1) (port pb1-2) (volts ?:v)) 
  231.               :circuit-1 :network-rules :include-datum-justification nil)
  232. (demo-graph-support-tree rule:*support-tree*)
  233.  
  234. (rule:support '(voltage (port pb1-1) (port pb1-2) (volts ?:v)) 
  235.               :circuit-1 :network-rules :include-datum-justification t)
  236. (demo-graph-support-tree rule:*support-tree*)
  237.  
  238. ;;; Something that takes application of one voltage propagation rule.
  239.  
  240. (rule:support '(voltage (port pl1-1) (port pl1-2) (volts ?:v))
  241.               :circuit-1 :network-rules)
  242. (demo-graph-support-tree rule:*support-tree*)
  243.  
  244. ;;; This requires problem solving across resistor to get voltage.
  245. ;;; Makes a rather complex graph.
  246.  
  247. (dnet:defvariable "LUM")
  248. (rule:support '(brightness (light l1) (lumens ?:lum))
  249.               :circuit-1 :network-rules :record-failure nil)
  250. (demo-graph-support-tree rule:*support-tree*)
  251.  
  252. ;;; A harder test, this takes work to get past the resistor.
  253.  
  254. (rule:support '(brightness (light l2) (lumens ?:lum))
  255.               :circuit-1 :network-rules :record-failure nil)
  256. (demo-graph-support-tree rule:*support-tree*)
  257.  
  258. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  259. ;;; MORE TESTS - Taken from Eriksson & Johannason AAAI-85.
  260. ;;; This part of the demo shows some problems with this backchainer.
  261. ;;; It does redundant reasoning, and needs a TMS to prevent this.
  262. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  263. ;;;; The database of facts.  Evaluate as a group.
  264.  
  265. (dnet:make-dnet ':EE-DB
  266.   :indexpr-hook 'NIL
  267.   :delexpr-hook 'NIL
  268.   :info 'NIL)
  269.  
  270. ;;;                   John                 
  271. ;;;                   /   \                
  272. ;;;                  f     f               
  273. ;;;                 /       \              
  274. ;;;               Ada       Per            
  275. ;;;                        /   \           
  276. ;;;                       f     f          
  277. ;;;                      /       \         
  278. ;;;                     Eva      Pia       
  279. ;;;                      |        |        
  280. ;;;                      m        m        
  281. ;;;                      |        |        
  282. ;;;                     Tom      Tim       
  283.    
  284. (dnet:indexpr '(FATHER ADA JOHN) ':EE-DB '(#S(RULE:JUSTIFICATION RULE::WARRANT :ASSERTED RULE::GROUNDS :DAN-SAYS-SO TIME 2808797026)))
  285. (dnet:indexpr '(FATHER PER JOHN) ':EE-DB '(#S(RULE:JUSTIFICATION RULE::WARRANT :ASSERTED RULE::GROUNDS :DAN-SAYS-SO TIME 2808797032)))
  286. (dnet:indexpr '(FATHER PIA PER) ':EE-DB '(#S(RULE:JUSTIFICATION RULE::WARRANT :ASSERTED RULE::GROUNDS :DAN-SAYS-SO TIME 2808797040)))
  287. (dnet:indexpr '(FATHER EVA PER) ':EE-DB '(#S(RULE:JUSTIFICATION RULE::WARRANT :ASSERTED RULE::GROUNDS :DAN-SAYS-SO TIME 2808797048)))
  288. (dnet:indexpr '(MOTHER TOM EVA) ':EE-DB '(#S(RULE:JUSTIFICATION RULE::WARRANT :ASSERTED RULE::GROUNDS :DAN-SAYS-SO TIME 2808797062)))
  289. (dnet:indexpr '(MOTHER TIM PIA) ':EE-DB '(#S(RULE:JUSTIFICATION RULE::WARRANT :ASSERTED RULE::GROUNDS :DAN-SAYS-SO TIME 2808797070)))
  290.  
  291. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  292. ;;; Rules
  293.  
  294. (dnet:make-dnet :ee-rb)
  295.  
  296. (rule:defvariables "X" "Y" "Z")
  297.  
  298. (rule:rule RULE-1
  299.  :ANTECEDENT        (father ?:x ?:y)
  300.  :CONSEQUENT        (parent ?:x ?:y)
  301.  :DIRECTIONS        :both
  302.  :INTERNED-IN       (:ee-rb)
  303.  :INFO              nil
  304.  :COMMENTS          "Your father is your parent.")
  305. (rule:add-rule 'rule-1 :ee-rb)
  306.  
  307. (rule:rule RULE-2
  308.  :ANTECEDENT        (mother ?:x ?:y)
  309.  :CONSEQUENT        (parent ?:x ?:y)
  310.  :DIRECTIONS        :both
  311.  :INTERNED-IN       (:ee-rb)
  312.  :INFO              nil
  313.  :COMMENTS          "Your mother is your parent.")
  314. (rule:add-rule 'rule-2 :ee-rb)
  315.  
  316. (rule:rule RULE-3
  317.  :ANTECEDENT        (parent ?:x ?:y)
  318.  :CONSEQUENT        (ancestor ?:x ?:y)
  319.  :DIRECTIONS        :both
  320.  :INTERNED-IN       (:ee-rb)
  321.  :INFO              nil
  322.  :COMMENTS          "Your parent is an ancestor.")
  323. (rule:add-rule 'rule-3 :ee-rb)
  324.  
  325. (rule:rule RULE-4
  326.  :ANTECEDENT        (:and (parent ?:x ?:z) (ancestor ?:z ?:y))
  327.  :CONSEQUENT        (ancestor ?:x ?:y)
  328.  :DIRECTIONS        :both
  329.  :INTERNED-IN       (:ee-rb)
  330.  :INFO              nil
  331.  :COMMENTS          "A parent of an ancestor is also an ancestor.")
  332. (rule:add-rule 'rule-4 :ee-rb)
  333.  
  334. (rule:rule RULE-5
  335.  :ANTECEDENT        (ancestor ?:x ?:y)
  336.  :CONSEQUENT        (related ?:x ?:y)
  337.  :DIRECTIONS        :both
  338.  :INTERNED-IN       (:ee-rb)
  339.  :INFO              nil
  340.  :COMMENTS          "You are related to your ancestor.")
  341. (rule:add-rule 'rule-5 :ee-rb)
  342.  
  343. (rule:rule RULE-6
  344.  :ANTECEDENT        (:and (ancestor ?:x ?:z) (ancestor ?:y ?:z))
  345.  :CONSEQUENT        (related ?:x ?:y)
  346.  :DIRECTIONS        :both
  347.  :INTERNED-IN       (:ee-rb)
  348.  :INFO              nil
  349.  :COMMENTS          "You are related to anyone with a common ancestor.")
  350. (rule:add-rule 'rule-6 :ee-rb)
  351.  
  352. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  353. ;;; Tests.
  354.  
  355. ;;; (trace rule:retrieve rule::retrieve-bindings rule::retrieve-backchain 
  356. ;;;        rule::retrieve-and rule::retrieve-or)
  357.  
  358. ;;; Simple.
  359.  
  360. (rule:retrieve '(father ?:x john) :ee-db :ee-rb)
  361.  
  362. (rule:support '(father ?:x john) :ee-db :ee-rb)
  363. (demo-graph-support-tree rule:*support-tree*)
  364.  
  365. (rule:retrieve '(ancestor ?:x per) :ee-db :ee-rb)
  366.  
  367. (rule:support '(ancestor ?:x per) :ee-db :ee-rb)
  368. (demo-graph-support-tree rule:*support-tree*)
  369.  
  370. ;;; This can take a while.
  371.  
  372. (rule:support '(related ada ?:x) :ee-db :ee-rb)
  373. (demo-graph-support-tree rule:*support-tree*)
  374.  
  375. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  376. ;;; EOF
  377.